AtomicIntegerArray এবং AtomicLongArray: গাইড ও নোট

AtomicIntegerArray এবং AtomicLongArray হল Java-এর java.util.concurrent.atomic প্যাকেজের ক্লাস, যা thread-safe এবং atomic operations সাপোর্ট করে। এগুলো multi-threaded environment-এ integer এবং long টাইপের ডেটা ম্যানেজমেন্টের জন্য ব্যবহৃত হয়। প্রতিটি অপারেশন (যেমন রিড, রাইট, ইনক্রিমেন্ট) অখণ্ডভাবে (atomic) পরিচালিত হয়, যার ফলে data consistency বজায় থাকে এবং race condition প্রতিরোধ করা যায়।

AtomicIntegerArray

পরিচিতি

• এটি integer array এর উপর atomic operations পরিচালনা করে।
• একাধিক থ্রেড একসঙ্গে একটি AtomicIntegerArray এর মান পরিবর্তন করতে পারে, কিন্তু প্রতিটি অপারেশন নিরাপদভাবে (thread-safe) সম্পন্ন হয়।

মুল Constructor

AtomicIntegerArray(int length)
AtomicIntegerArray(int[] array)

• প্রথম কনস্ট্রাক্টর একটি নির্দিষ্ট আকারের (length) অ্যারে তৈরি করে।
• দ্বিতীয় কনস্ট্রাক্টর একটি বিদ্যমান integer array থেকে নতুন AtomicIntegerArray তৈরি করে।

AtomicIntegerArray এর গুরুত্বপূর্ণ মেথড

• get(int index): নির্দিষ্ট ইনডেক্স থেকে মান রিটার্ন করে।
• set(int index, int newValue): নির্দিষ্ট ইনডেক্সে একটি নতুন মান সেট করে।
• getAndSet(int index, int newValue): পুরোনো মান রিটার্ন করে এবং একটি নতুন মান সেট করে।
• incrementAndGet(int index): ইনডেক্সের মান ১ বৃদ্ধি করে এবং নতুন মান রিটার্ন করে।
• getAndIncrement(int index): ইনডেক্সের মান ১ বৃদ্ধি করার আগে পুরোনো মান রিটার্ন করে।
• compareAndSet(int index, int expectedValue, int newValue): যদি ইনডেক্সের মান expectedValue এর সমান হয়, তাহলে newValue দিয়ে আপডেট করে।

উদাহরণ

import java.util.concurrent.atomic.AtomicIntegerArray;

public class Main {
    public static void main(String[] args) {
        int[] values = {10, 20, 30};
        AtomicIntegerArray atomicArray = new AtomicIntegerArray(values);

        // Get and Set Operations
        System.out.println("Initial value at index 0: " + atomicArray.get(0)); // 10
        atomicArray.set(0, 50);
        System.out.println("Updated value at index 0: " + atomicArray.get(0)); // 50

        // Increment Operations
        System.out.println("Value before increment: " + atomicArray.getAndIncrement(1)); // 20
        System.out.println("Value after increment: " + atomicArray.get(1)); // 21

        // Compare and Set
        boolean success = atomicArray.compareAndSet(2, 30, 100);
        System.out.println("Compare and Set successful: " + success); // true
        System.out.println("Value at index 2: " + atomicArray.get(2)); // 100
    }
}

AtomicLongArray

পরিচিতি

• এটি long array এর উপর atomic operations পরিচালনা করে।
• এটি একইভাবে thread-safe এবং মাল্টি-থ্রেডেড প্রোগ্রামিংয়ের জন্য উপযোগী।

মূল Constructor

AtomicLongArray(int length)
AtomicLongArray(long[] array)

• প্রথম কনস্ট্রাক্টর একটি নির্দিষ্ট আকারের (length) AtomicLongArray তৈরি করে।
• দ্বিতীয় কনস্ট্রাক্টর একটি বিদ্যমান long array থেকে নতুন AtomicLongArray তৈরি করে।

AtomicLongArray এর গুরুত্বপূর্ণ মেথড

• get(int index): নির্দিষ্ট ইনডেক্স থেকে মান রিটার্ন করে।
• set(int index, long newValue): নির্দিষ্ট ইনডেক্সে একটি নতুন মান সেট করে।
• getAndSet(int index, long newValue): পুরোনো মান রিটার্ন করে এবং একটি নতুন মান সেট করে।
• incrementAndGet(int index): ইনডেক্সের মান ১ বৃদ্ধি করে এবং নতুন মান রিটার্ন করে।
• getAndIncrement(int index): ইনডেক্সের মান ১ বৃদ্ধি করার আগে পুরোনো মান রিটার্ন করে।
• compareAndSet(int index, long expectedValue, long newValue): যদি ইনডেক্সের মান expectedValue এর সমান হয়, তাহলে newValue দিয়ে আপডেট করে।

উদাহরণ

import java.util.concurrent.atomic.AtomicLongArray;

public class Main {
    public static void main(String[] args) {
        long[] values = {100L, 200L, 300L};
        AtomicLongArray atomicArray = new AtomicLongArray(values);

        // Get and Set Operations
        System.out.println("Initial value at index 0: " + atomicArray.get(0)); // 100
        atomicArray.set(0, 500L);
        System.out.println("Updated value at index 0: " + atomicArray.get(0)); // 500

        // Increment Operations
        System.out.println("Value before increment: " + atomicArray.getAndIncrement(1)); // 200
        System.out.println("Value after increment: " + atomicArray.get(1)); // 201

        // Compare and Set
        boolean success = atomicArray.compareAndSet(2, 300L, 1000L);
        System.out.println("Compare and Set successful: " + success); // true
        System.out.println("Value at index 2: " + atomicArray.get(2)); // 1000
    }
}

AtomicIntegerArray এবং AtomicLongArray এর প্রয়োগ ক্ষেত্র

• Thread-Safe Counter: মাল্টি-থ্রেডের মধ্যে কাউন্টার পরিচালনা করা।
• Shared Resources: একাধিক থ্রেডের মধ্যে শেয়ার করা ডেটার উপর কাজ করা।
• Concurrency Control: মাল্টি-থ্রেডেড অ্যাপ্লিকেশনগুলিতে ডেটা কনসিস্টেন্সি বজায় রাখা।
• Atomic Updates: ডেটা রিড এবং রাইট করতে লক-মুক্ত (lock-free) পদ্ধতি ব্যবহার।

AtomicIntegerArray বনাম AtomicLongArray

উপসংহার

AtomicIntegerArray এবং AtomicLongArray ক্লাস মাল্টি-থ্রেডিংয়ে ডেটা পরিচালনার জন্য খুবই কার্যকর। এগুলো থ্রেড-সেফ increment, decrement, এবং conditional update সাপোর্ট করে, যা data consistency এবং performance নিশ্চিত করে।

Atomic Arrays হল JavaScript-এ Atomics API এবং SharedArrayBuffer এর সাথে ব্যবহৃত একটি বিশেষ কনসেপ্ট, যা মাল্টি-থ্রেডেড প্রোগ্রামিংয়ে অ্যারে ডেটা পরিচালনায় atomic operations নিশ্চিত করে। এটি TypedArray এর উপর ভিত্তি করে কাজ করে, যা SharedArrayBuffer এর মাধ্যমে মেমোরি শেয়ার করতে সক্ষম।

Atomic Arrays: Introduction

Atomic Arrays মূলত SharedArrayBuffer এর উপর ভিত্তি করে তৈরি করা TypedArray। এগুলোতে Atomics API ব্যবহার করে থ্রেড-সেফ অপারেশন সম্পাদন করা হয়। মাল্টি-থ্রেডিংয়ের সময় ডেটা ম্যানিপুলেশনে Race Condition এবং Data Corruption প্রতিরোধ করার জন্য এগুলো ব্যবহৃত হয়।

কেন Atomic Arrays প্রয়োজন?

• Thread-safe Data Management: একাধিক থ্রেড একসঙ্গে ডেটা পড়া এবং লেখা করতে পারে।
• Synchronization: থ্রেডগুলোর মধ্যে ডেটা সিঙ্ক্রোনাইজ করে।
• Performance Optimization: লক-মুক্ত (lock-free) প্রোগ্রামিংয়ের মাধ্যমে পারফরম্যান্স বৃদ্ধি করে।
• Data Integrity: ডেটা সঠিকভাবে আপডেট এবং পরিচালনা নিশ্চিত করে।

Atomic Arrays এর বৈশিষ্ট্য

• Thread-safety: একই সময়ে একাধিক থ্রেড ডেটার উপর কাজ করলেও ডেটার সঠিকতা বজায় থাকে।
• Atomic Operations: ডেটা পড়া, লেখা, এবং আপডেট করার জন্য নির্দিষ্ট মেথড।
• Shared Memory: SharedArrayBuffer ব্যবহার করে মেমোরি শেয়ার করা হয়।
• TypedArray Integration: Int8Array, Int16Array, Int32Array এর সাথে কাজ করে।

Atomic Arrays: কিভাবে কাজ করে?

Atomic Arrays এর অপারেশনগুলো Atomics API এর মাধ্যমে সম্পন্ন হয়। এটি সরাসরি TypedArray এর নির্দিষ্ট ইনডেক্সে কাজ করে এবং থ্রেড-সেফ অপারেশন নিশ্চিত করে।

স্টেপস:

1. SharedArrayBuffer তৈরি করুন।
2. TypedArray এর সাথে SharedArrayBuffer লিঙ্ক করুন।
3. Atomics API ব্যবহার করে ডেটা পড়া বা আপডেট করুন।

Atomic Arrays এর ফাংশনসমূহ

১. Atomics.load(typedArray, index)

একটি নির্দিষ্ট ইনডেক্স থেকে ডেটা পড়ে।

const buffer = new SharedArrayBuffer(16); // 16-byte মেমোরি
const intArray = new Int32Array(buffer);
intArray[0] = 42;

const value = Atomics.load(intArray, 0);
console.log(value); // আউটপুট: 42

২. Atomics.store(typedArray, index, value)

নির্দিষ্ট ইনডেক্সে একটি ভ্যালু সেট করে।

Atomics.store(intArray, 1, 100);
console.log(intArray[1]); // আউটপুট: 100

৩. Atomics.add(typedArray, index, value)

নির্দিষ্ট ইনডেক্সে একটি মান যোগ করে এবং পূর্ববর্তী মান রিটার্ন করে।

const previous = Atomics.add(intArray, 1, 10);
console.log(previous); // আউটপুট: 100
console.log(intArray[1]); // আউটপুট: 110

৪. Atomics.sub(typedArray, index, value)

নির্দিষ্ট ইনডেক্স থেকে একটি মান বিয়োগ করে এবং পূর্ববর্তী মান রিটার্ন করে।

Atomics.sub(intArray, 1, 10);
console.log(intArray[1]); // আউটপুট: 100

৫. Atomics.compareExchange(typedArray, index, expected, replacement)

ইনডেক্সে যদি মান expected এর সমান হয়, তবে সেটি replacement দিয়ে প্রতিস্থাপন করে।

const result = Atomics.compareExchange(intArray, 1, 100, 200);
console.log(result); // আউটপুট: 100
console.log(intArray[1]); // আউটপুট: 200

৬. Atomics.wait(typedArray, index, value, timeout)

নির্দিষ্ট ইনডেক্সে একটি মান পরিবর্তনের জন্য অপেক্ষা করে।

Atomics.wait(intArray, 0, 42, 1000); // ১ সেকেন্ড অপেক্ষা করবে যদি মান ৪২ না হয়

৭. Atomics.notify(typedArray, index, count)

একটি নির্দিষ্ট সংখ্যা পর্যন্ত থ্রেডকে জাগিয়ে তোলে।

Atomics.notify(intArray, 0, 1); // একটি থ্রেডকে জাগিয়ে তোলে

Atomic Arrays এর ব্যবহার

উদাহরণ ১: মাল্টি-থ্রেডিংয়ে Atomic Arrays

const buffer = new SharedArrayBuffer(1024);
const intArray = new Int32Array(buffer);

// Worker 1
Atomics.store(intArray, 0, 50);

// Worker 2
Atomics.add(intArray, 0, 10);

// Main Thread
console.log(Atomics.load(intArray, 0)); // আউটপুট: 60

উদাহরণ ২: ডেটা আপডেট এবং সিঙ্ক্রোনাইজেশন

const buffer = new SharedArrayBuffer(1024);
const intArray = new Int32Array(buffer);

function increment() {
    for (let i = 0; i < 1000; i++) {
        Atomics.add(intArray, 0, 1);
    }
}

increment();
console.log(Atomics.load(intArray, 0)); // আউটপুট: 1000

Atomic Arrays ব্যবহারের সুবিধা

1. Thread-safe Operations: মাল্টি-থ্রেডিংয়ে ডেটা সঠিক রাখে।
2. Performance: লক-মুক্ত (lock-free) অপারেশন নিশ্চিত করে।
3. Data Consistency: একাধিক থ্রেড কাজ করলেও ডেটার সঠিকতা বজায় থাকে।
4. Concurrency Management: থ্রেডগুলোর মধ্যে সিঙ্ক্রোনাইজেশন নিশ্চিত করে।

Atomic Arrays এর সীমাবদ্ধতা

1. Complex API: নতুনদের জন্য এটি জটিল হতে পারে।
2. Memory Limitation: SharedArrayBuffer এর সাইজ ফিক্সড থাকে।
3. Browser Support: সব ব্রাউজারে সাপোর্ট নেই।
4. Limited Data Types: শুধুমাত্র TypedArray এর সাথে কাজ করে।

Atomic Arrays মাল্টি-থ্রেডেড অ্যাপ্লিকেশনে ডেটা ম্যানেজমেন্ট এবং সিঙ্ক্রোনাইজেশনের জন্য একটি শক্তিশালী টুল। এটি Web Workers এর মাধ্যমে ডেটা শেয়ারিং এবং ডেটার উপর নির্ভরযোগ্য অপারেশন নিশ্চিত করে।

Atomic Arrays হল Java এর java.util.concurrent.atomic প্যাকেজের একটি ফিচার যা atomic operations এর মাধ্যমে একটি অ্যারের উপাদানগুলোকে থ্রেড-সেফভাবে পরিচালনা করতে ব্যবহৃত হয়। এটি AtomicIntegerArray, AtomicLongArray, এবং AtomicReferenceArray এর মতো ক্লাস সরবরাহ করে।

এই ক্লাসগুলোতে এমন মেথড রয়েছে যা একাধিক থ্রেডের মধ্যে synchronization ছাড়াই কাজ করতে পারে। এর ফলে মাল্টি-থ্রেডেড প্রোগ্রামিংয়ে ডেটা সঠিকতা বজায় রাখা সহজ হয়।

গুরুত্বপূর্ণ মেথডসমূহ এবং তাদের কার্যপ্রণালী

১. get(index)

এই মেথডটি অ্যারের একটি নির্দিষ্ট index এর মান পড়ে।
এটি থ্রেড-সেফ।

AtomicIntegerArray atomicArray = new AtomicIntegerArray(5);
atomicArray.set(0, 10); // Index 0 তে 10 সেট করা

System.out.println(atomicArray.get(0)); // আউটপুট: 10

২. set(index, value)

এই মেথডটি অ্যারের একটি নির্দিষ্ট index এ একটি নতুন মান সেট করে।
এটি থ্রেড-সেফ এবং atomic।

AtomicIntegerArray atomicArray = new AtomicIntegerArray(5);
atomicArray.set(1, 20); // Index 1 এ 20 সেট করা

System.out.println(atomicArray.get(1)); // আউটপুট: 20

৩. getAndAdd(index, delta)

এই মেথডটি অ্যারের একটি নির্দিষ্ট index এর বর্তমান মান রিটার্ন করে এবং তারপর একটি নির্দিষ্ট delta মান যোগ করে।
এটি থ্রেড-সেফ এবং atomic।

AtomicIntegerArray atomicArray = new AtomicIntegerArray(5);
atomicArray.set(2, 30); // Index 2 তে 30 সেট করা

int previousValue = atomicArray.getAndAdd(2, 5); // 5 যোগ করার আগে পুরানো মান রিটার্ন করবে
System.out.println("Previous Value: " + previousValue); // আউটপুট: 30
System.out.println("Updated Value: " + atomicArray.get(2)); // আউটপুট: 35

৪. compareAndSet(index, expectedValue, newValue)

এই মেথডটি একটি নির্দিষ্ট index এর মান পরীক্ষা করে এবং যদি সেটি expectedValue এর সমান হয়, তবে এটি newValue তে আপডেট করে। সফল হলে এটি true রিটার্ন করে, অন্যথায় false।
এটি থ্রেড-সেফ এবং atomic।

AtomicIntegerArray atomicArray = new AtomicIntegerArray(5);
atomicArray.set(3, 40); // Index 3 এ 40 সেট করা

boolean isUpdated = atomicArray.compareAndSet(3, 40, 50); // যদি 40 হয়, তবে 50 তে আপডেট করবে
System.out.println("Update Successful: " + isUpdated); // আউটপুট: true
System.out.println("Updated Value: " + atomicArray.get(3)); // আউটপুট: 50

Atomic Arrays এর বৈশিষ্ট্য

• Thread-Safe Operations: একাধিক থ্রেডের মধ্যে ডেটা পরিবর্তন সঠিকভাবে সম্পন্ন হয়।
• Non-blocking Mechanism: CAS (Compare-And-Swap) মেকানিজম ব্যবহার করে ডেটা আপডেট করে, যা লক-মুক্ত এবং পারফরম্যান্স বৃদ্ধিতে কার্যকর।
• Immutable Index: অ্যারের ইনডেক্স স্থির (immutable), তাই একাধিক থ্রেড একই ইনডেক্সে কাজ করলেও ডেটা সঠিক থাকে।

উদাহরণ: AtomicIntegerArray এর ব্যবহার

import java.util.concurrent.atomic.AtomicIntegerArray;

public class AtomicArrayExample {
    public static void main(String[] args) {
        // Atomic Array তৈরি
        AtomicIntegerArray atomicArray = new AtomicIntegerArray(5);

        // মান সেট করা
        atomicArray.set(0, 10);
        atomicArray.set(1, 20);
        atomicArray.set(2, 30);

        // get() ব্যবহার
        System.out.println("Index 1 Value: " + atomicArray.get(1)); // আউটপুট: 20

        // getAndAdd() ব্যবহার
        System.out.println("Index 2 Old Value: " + atomicArray.getAndAdd(2, 5)); // আউটপুট: 30
        System.out.println("Index 2 New Value: " + atomicArray.get(2)); // আউটপুট: 35

        // compareAndSet() ব্যবহার
        boolean isUpdated = atomicArray.compareAndSet(1, 20, 50); // যদি 20 হয়, তবে 50 তে আপডেট করবে
        System.out.println("Compare-And-Set Successful: " + isUpdated); // আউটপুট: true
        System.out.println("Index 1 New Value: " + atomicArray.get(1)); // আউটপুট: 50
    }
}

Atomic Arrays এর সুবিধা

• Thread-safe Reads এবং Writes: একাধিক থ্রেডের ক্ষেত্রে ডেটা নিরাপদ থাকে।
• Lock-Free Synchronization: লক ব্যবহার ছাড়াই ডেটা ম্যানিপুলেশন করা যায়।
• High Performance: Synchronization blocks বা locks এর তুলনায় দ্রুত কাজ করে।

Atomic Arrays এর সীমাবদ্ধতা

1. Fixed Size: Atomic Arrays এর আকার একবার নির্ধারণ করার পর পরিবর্তন করা যায় না।
2. Single Type: প্রতিটি অ্যারে শুধুমাত্র একটি নির্দিষ্ট ডেটা টাইপ (যেমন Integer, Long) ধারণ করতে পারে।
3. Complex Logic: জটিল লজিক বা ডেটা স্ট্রাকচার ব্যবহারের ক্ষেত্রে অতিরিক্ত ব্যবস্থাপনার প্রয়োজন হতে পারে।

উপসংহার

Atomic Arrays মাল্টি-থ্রেডেড প্রোগ্রামিংয়ে ডেটা ম্যানিপুলেশনের সময় synchronization এবং atomicity নিশ্চিত করার জন্য একটি কার্যকর সমাধান। এর মেথডগুলো যেমন get(), set(), getAndAdd(), এবং compareAndSet() মাল্টি-থ্রেডিংয়ের চ্যালেঞ্জ মোকাবিলায় বিশেষ ভূমিকা রাখে। এটি উচ্চ-পারফরম্যান্স অ্যাপ্লিকেশন এবং ডেটা সঠিকতা বজায় রাখার জন্য অত্যন্ত উপযোগী।